package com.tennis.tennisreservation.controller;

import com.tennis.tennisreservation.common.Result;
import com.tennis.tennisreservation.entity.User;
import com.tennis.tennisreservation.service.UserService;
import com.tennis.tennisreservation.service.WxService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * 用户控制器
 * 处理前端发来的用户相关请求
 */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;
    
    @Autowired
    private WxService wxService;

    /**
     * 获取用户列表
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @param keyword 关键词（用户名或手机号）
     * @return 分页用户数据
     */
    @GetMapping("/list")
    public Result<?> getUserList(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) String keyword) {
        
        // 获取用户列表和总数
        List<User> users = userService.getUserList(pageNum, pageSize, keyword);
        long total = userService.countUsers(keyword);
        
        // 组装返回数据
        Map<String, Object> data = new HashMap<>();
        data.put("list", users);
        data.put("total", total);
        
        return Result.success(data);
    }

    /**
     * 删除用户
     * @param id 用户ID
     * @return 删除结果
     */
    @DeleteMapping("/delete/{id}")
    public Result<?> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return Result.success("删除成功");
    }

    /**
     * 根据手机号查询用户信息
     * @param phone 用户手机号
     * @return 查询结果
     */
    @GetMapping("/find")
    public Result<?> findUserByPhone(@RequestParam String phone) {
        Optional<User> userOptional = userService.findByPhone(phone);
        return userOptional
                .map(user -> Result.success(user)) // 查询到，成功返回
                .orElseGet(() -> Result.fail("用户不存在")); // 查询不到，失败返回
    }

    /**
     * 新增或更新用户信息
     * @param user 用户对象
     * @return 保存结果
     */
    @PostMapping("/save")
    public Result<User> saveUser(@RequestBody User user) {
        User savedUser = userService.saveUser(user);
        return Result.success(savedUser);
    }

    /**
     * 用户注册接口
     * @param request 请求体，包含手机号和密码
     * @return 用户信息
     */
    @PostMapping("/register")
    public Result<?> register(@RequestBody UserRegisterRequest request) {
        try {
            // 调用 UserService 注册用户
            User user = userService.register(request.getPhone());
            return Result.success(user); // 返回注册成功的用户信息
        } catch (Exception e) {
            return Result.fail(e.getMessage()); // 失败返回错误信息
        }
    }

    /**
     * 用户登录接口（用户名密码登录）
     */
    @PostMapping("/login")
    public Result<?> login(@RequestBody UserLoginRequest request) {
        try {
            // 检查参数
            if (request.getUsername() == null || request.getUsername().isEmpty()) {
                return Result.fail("用户名不能为空");
            }
            if (request.getPassword() == null || request.getPassword().isEmpty()) {
                return Result.fail("密码不能为空");
            }
            
            // 直接使用用户名密码登录方法
            User user = userService.loginByUsername(request.getUsername(), request.getPassword());
            
            // 返回用户信息和token
            Map<String, Object> data = new HashMap<>();
            data.put("user", user);
            data.put("token", "user-token-" + System.currentTimeMillis()); // 简单的token生成
            
            return Result.success(data);
        } catch (Exception e) {
            return Result.fail(e.getMessage()); // 失败返回错误信息
        }
    }
    
    /**
     * 用户登录接口（手机号登录，已废弃，仅供兼容）
     */
    @PostMapping("/login/phone")
    public Result<?> loginByPhone(@RequestBody UserLoginRequest request) {
        try {
            if (request.getPhone() == null || request.getPhone().isEmpty()) {
                return Result.fail("手机号不能为空");
            }
            // 调用登录逻辑
            User user = userService.login(request.getPhone());
            
            // 返回用户信息和token
            Map<String, Object> data = new HashMap<>();
            data.put("user", user);
            data.put("token", "user-token-" + System.currentTimeMillis()); // 简单的token生成
            
            return Result.success(data);
        } catch (Exception e) {
            return Result.fail(e.getMessage()); // 失败返回错误信息
        }
    }

    /**
     * 微信小程序登录接口
     * 如果用户不存在，则创建用户后再登录
     * @param request 请求参数
     * @return 登录结果
     */
    @PostMapping("/wx-login")
    public Result<?> wxLogin(@RequestBody WxLoginRequest request) {
        try {
            // 参数验证
            if (request.getUsername() == null || request.getUsername().isEmpty()) {
                return Result.fail("用户名不能为空");
            }
            
            // 1. 检查用户是否存在
            Optional<User> existingUser = userService.findByPhone(request.getUsername());
            User user;
            
            if (existingUser.isPresent()) {
                // 2. 用户存在，直接登录
                user = existingUser.get();
                System.out.println("用户已存在，直接登录: " + user.getUsername());
            } else {
                // 3. 用户不存在，创建新用户
                user = new User();
                user.setUsername(request.getUsername());
                user.setPhone(request.getUsername()); // 手机号作为用户名
                user.setName(request.getName());
                user.setPassword(request.getPassword() != null ? request.getPassword() : "123456"); // 默认密码
                user.setRole(request.getRole() != null ? request.getRole() : "USER"); // 默认角色
                user.setCreateTime(LocalDateTime.now());
                user.setUpdateTime(LocalDateTime.now());
                
                // 保存新用户
                user = userService.saveUser(user);
                System.out.println("创建新用户成功: " + user.getUsername());
            }
            
            // 4. 构建返回数据
            Map<String, Object> data = new HashMap<>();
            data.put("userInfo", user);
            data.put("token", "wx-token-" + System.currentTimeMillis());
            
            return Result.success(data);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("微信登录失败: " + e.getMessage());
        }
    }

    /**
     * 获取所有用户
     * 不分页，返回全部用户数据
     * @return 所有用户列表
     */
    @GetMapping("/all")
    public Result<?> getAllUsers() {
        List<User> users = userService.getAllUsers();
        return Result.success(users);
    }

    /**
     * 通过微信code获取openid
     * 小程序登录时使用，获取用户openid并保存在本地
     * @param request 包含微信code的请求
     * @return 包含openid的响应
     */
    @PostMapping("/wx-code-to-openid")
    public Result<?> getOpenidByCode(@RequestBody WxCodeRequest request) {
        try {
            if (request.getCode() == null || request.getCode().isEmpty()) {
                return Result.fail("微信code不能为空");
            }
            
            // 调用微信服务获取openid
            String openid = wxService.getOpenidByCode(request.getCode());
            
            if (openid == null || openid.isEmpty()) {
                return Result.fail("获取openid失败");
            }
            
            // 构建返回数据
            Map<String, String> data = new HashMap<>();
            data.put("openid", openid);
            return Result.success(data);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("获取openid失败: " + e.getMessage());
        }
    }

    /**
     * 微信小程序手机号登录接口
     * 通过获取的手机号临时凭证，获取用户实际手机号并进行登录
     * @param request 请求参数
     * @return 登录结果
     */
    @PostMapping("/phone-login")
    public Result<?> phoneLogin(@RequestBody WxPhoneLoginRequest request) {
        try {
            // 参数验证
            if (request.getCode() == null || request.getCode().isEmpty()) {
                return Result.fail("手机号凭证不能为空");
            }
            
            // 1. 调用微信API获取用户手机号
            Map<String, Object> phoneResponse = wxService.getPhoneNumber(request.getCode());
            String phoneNumber = wxService.parsePhoneNumber(phoneResponse);
            
            if (phoneNumber == null || phoneNumber.isEmpty()) {
                return Result.fail("获取手机号失败");
            }
            
            // 2. 检查用户是否存在
            Optional<User> existingUser = userService.findByPhone(phoneNumber);
            User user;
            
            if (existingUser.isPresent()) {
                // 3. 用户存在，更新用户信息
                user = existingUser.get();
                System.out.println("用户已存在，通过手机号直接登录: " + user.getUsername());
                
                // 如果请求中有头像和昵称，则更新用户信息
                boolean needUpdate = false;
                
                if (request.getAvatarUrl() != null && !request.getAvatarUrl().isEmpty()) {
                    user.setAvatarUrl(request.getAvatarUrl());
                    needUpdate = true;
                }
                
                if (request.getNickName() != null && !request.getNickName().isEmpty()) {
                    user.setName(request.getNickName());
                    needUpdate = true;
                }
                
                if (needUpdate) {
                    user.setUpdateTime(LocalDateTime.now());
                    user = userService.saveUser(user);
                    System.out.println("用户信息已更新: " + user.getUsername());
                }
            } else {
                // 4. 用户不存在，创建新用户
                user = new User();
                user.setUsername(phoneNumber); // 手机号作为用户名
                user.setPhone(phoneNumber);
                
                // 使用请求中提供的昵称和头像（如果有）
                user.setName(request.getNickName() != null && !request.getNickName().isEmpty() 
                        ? request.getNickName() : "微信用户");
                
                if (request.getAvatarUrl() != null && !request.getAvatarUrl().isEmpty()) {
                    user.setAvatarUrl(request.getAvatarUrl());
                }
                
                user.setPassword("123456"); // 默认密码
                user.setRole(request.getRole() != null ? request.getRole() : "USER"); // 默认角色
                user.setCreateTime(LocalDateTime.now());
                user.setUpdateTime(LocalDateTime.now());
                
                // 保存新用户
                user = userService.saveUser(user);
                System.out.println("创建新用户成功: " + user.getUsername());
            }
            
            // 5. 构建返回数据
            Map<String, Object> data = new HashMap<>();
            data.put("userInfo", user);
            data.put("token", "wx-phone-" + System.currentTimeMillis());
            
            return Result.success(data);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("微信手机号登录失败: " + e.getMessage());
        }
    }

    /**
     * 更新用户余额
     * @param params 包含userId、rechargeBalance、giftBalance的参数对象
     * @return 更新结果
     */
    @PostMapping("/update-balance")
    public Result<?> updateBalance(@RequestBody Map<String, Object> params) {
        try {
            // 打印收到的参数，便于调试
            System.out.println("更新余额接收参数: " + params);
            
            // 提取必要参数
            Long userId = Long.valueOf(params.get("userId").toString());
            String rechargeBalance = params.get("rechargeBalance").toString();
            String giftBalance = params.get("giftBalance").toString();
            
            // 调用服务层方法更新余额
            User updatedUser = userService.updateUserBalance(userId, rechargeBalance, giftBalance);
            
            // 返回更新后的用户信息
            return Result.success(updatedUser);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("更新余额失败: " + e.getMessage());
        }
    }

    /**
     * 获取当前登录用户的详细信息
     * 目前仅根据请求头中的Authorization获取用户信息
     * @return 当前登录用户信息
     */
    @GetMapping("/info")
    public Result<?> getUserInfo(@RequestHeader(value = "Authorization", required = false) String token) {
        try {
            // 在实际项目中应该从token中解析用户标识，并根据用户标识获取最新用户信息
            // 这里简化处理，从请求头获取Authorization，假设它包含userId
            
            // 如果没有传token，返回错误信息
            if (token == null || token.isEmpty()) {
                return Result.fail("未登录或登录已过期");
            }
            
            // 从token中解析用户ID（简化处理）
            // 格式假设为"Bearer {userId}"
            String userId = null;
            if (token.startsWith("Bearer ")) {
                userId = token.substring(7);
            } else {
                userId = token;
            }
            
            // 尝试从数据库获取用户信息
            try {
                Long userIdLong = Long.valueOf(userId);
                Optional<User> user = userService.findById(userIdLong);
                
                if (user.isPresent()) {
                    return Result.success(user.get());
                } else {
                    return Result.fail("用户不存在");
                }
            } catch (NumberFormatException e) {
                // 如果userId不是有效的数字，尝试根据用户名查找
                Optional<User> user = userService.findByUsername(userId);
                
                if (user.isPresent()) {
                    return Result.success(user.get());
                } else {
                    return Result.fail("用户不存在");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("获取用户信息失败: " + e.getMessage());
        }
    }
}

/**
 * 微信登录请求参数
 */
class WxLoginRequest {
    private String username; // 用户名/手机号
    private String name;     // 用户名称
    private String password; // 密码
    private String role;     // 角色
    
    public String getUsername() {
        return username;
    }
    
    public void setUsername(String username) {
        this.username = username;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getPassword() {
        return password;
    }
    
    public void setPassword(String password) {
        this.password = password;
    }
    
    public String getRole() {
        return role;
    }
    
    public void setRole(String role) {
        this.role = role;
    }
}

/**
 * 微信手机号登录请求参数
 */
class WxPhoneLoginRequest {
    private String code;     // 手机号获取凭证
    private String wxCode;   // 微信登录凭证
    private String platform; // 平台
    private String role;     // 角色
    private String avatarUrl; // 用户头像URL
    private String nickName;  // 用户昵称
    
    public String getCode() {
        return code;
    }
    
    public void setCode(String code) {
        this.code = code;
    }
    
    public String getWxCode() {
        return wxCode;
    }
    
    public void setWxCode(String wxCode) {
        this.wxCode = wxCode;
    }
    
    public String getPlatform() {
        return platform;
    }
    
    public void setPlatform(String platform) {
        this.platform = platform;
    }
    
    public String getRole() {
        return role;
    }
    
    public void setRole(String role) {
        this.role = role;
    }
    
    public String getAvatarUrl() {
        return avatarUrl;
    }
    
    public void setAvatarUrl(String avatarUrl) {
        this.avatarUrl = avatarUrl;
    }
    
    public String getNickName() {
        return nickName;
    }
    
    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
}

/**
 * 微信Code请求参数
 */
class WxCodeRequest {
    private String code; // 微信登录临时凭证
    
    public String getCode() {
        return code;
    }
    
    public void setCode(String code) {
        this.code = code;
    }
}
